/******************************************************************************
 * Copyright (C) 2014 ShenZhen YiHua Computer Co., Ltd.
 * All Rights Reserved.
 * 本软件为深圳怡化电脑股份有限公司开发研制。未经本公司正式书面同意，其他任何个人、团体
 * 不得使用、复制、修改或发布本软件.
 *****************************************************************************/
package net.dgg.dggcloud.core.util;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.StringTokenizer;

import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFDataFormat;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @ClassName〈FileUtil>
 * @Description〈文件操作工具类〉
 * @author 余松
 * @date 2014年10月31日 下午4:48:16
 */
public class FileUtil
{
    public static boolean flag = false;
    
    static Logger logger = LoggerFactory.getLogger(FileUtil.class);

    /*
     * 获取sql文件内容
     */
    @SuppressWarnings("resource")
    public static List<String> getSqlContext(String path) throws IOException
    {
        if (null == path || "".equals(path))
        {
            throw new FileNotFoundException("无效的Sql文件路径！");
        }
        BufferedReader br = new BufferedReader(new FileReader(path));

        StringBuffer sb = new StringBuffer(512);

        String r = br.readLine();

        while (r != null)
        {
            sb.append(r + "\n");

            r = br.readLine();
        }

        String arr[] = sb.toString().split(";");

        List<String> list = new ArrayList<String>();
        for (int i = 0; i < arr.length - 1; i++)
        {
            list.add(arr[i]);
        }

        return list;
    }

    /**
     * 删除文件
     * 
     * @creationDate: 2013-5-11
     * @param path
     */
    public static boolean deleteFile(String path)
    {
        File file = new File(path);
        // 路径为文件且不为空 删除
        if (file.isFile() && file.exists())
        {
            file.delete();
            flag = true;
        }
        return flag;
    }

    /**
     * 删除文件夹
     * 
     * @modificationDate:2013-5-11
     * @param path
     * @return
     */
    public static boolean deleteDirectory(String path)
    {
        // 如果路径最后不是文件分隔符结尾，自动添加文件分隔符
        if (!path.endsWith(File.separator))
        {
            path = path + File.separator;
        }
        File dirFile = new File(path);
        // 文件不为空且必须是文件夹
        if (!dirFile.exists() || !dirFile.isDirectory())
        {
            return false;
        }
        flag = true;
        File[] files = dirFile.listFiles();
        for (int i = 0; i < files.length; i++)
        {
            // 删除子文件
            if (files[i].isFile())
            {
                flag = deleteFile(files[i].getAbsolutePath());
                if (!flag)
                    break;
            }
            else
            {
                // 删除子目录
                flag = deleteDirectory(files[i].getAbsolutePath());
                if (!flag)
                    break;
            }
        }
        if (!flag)
            return false;
        // 删除当前目录
        if (dirFile.delete())
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    /**
     * @Title: importErrorToExls
     * @Description: 将集合数据写入EXCEL文件中
     * @param pathname
     * @param failRows
     * @return void 返回类型
     */
    public static String importErrorToExls(List<Object> list, String[] title)
    {
        int Year = CalendarUtils.getYear(new Date());
        int Month = CalendarUtils.getMonth(new Date()); 
        int Date = CalendarUtils.getDay(new Date()); 
		int Hours = CalendarUtils.getHour(new Date());
        int Minutes = CalendarUtils.getMinute(new Date());
        int Seconds = CalendarUtils.getSecond(new Date());
        String strTempFile = "EXPORT"+"_"+Year+"_"+Month+"_"+Date+"_"+Hours+"_"+Minutes+"_"+Seconds+".xls";
        String pathname = ConfigLoader.getConfigLoader().getVaule("salary_import_error_folder").trim() + "/" + strTempFile;
        HSSFWorkbook workBook = new HSSFWorkbook();
        try
        {
            HSSFSheet sheet = workBook.createSheet("Sheet1");

            HSSFCell cell = null;

            // 生成Excel标题
            HSSFRow row = sheet.createRow(0);
            for (int i = 0; i < title.length; i++)
            {
                cell = row.createCell(i);
                cell.setCellValue(StringUtils.toString(title[i]));
            }

            HSSFCellStyle cellStyle = workBook.createCellStyle();
            HSSFDataFormat format = workBook.createDataFormat();
            cellStyle.setDataFormat(format.getFormat("@"));

            // 写校验失败的数据到Excel
            for (int i = 0; i < list.size(); i++)
            {
                row = sheet.createRow(i + 1);
                Object obj[] = (Object[]) list.get(i);

                for (int j = 0; j < obj.length; j++)
                {
                    cell = row.createCell(j);
                    cell.setCellValue(StringUtils.toString(obj[j]));
                }
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }

        FileOutputStream fos = null;
        try
        {
            fos = new FileOutputStream(pathname);
            workBook.write(fos);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (fos != null)
            {
                try
                {
                    fos.close();
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
        }
        return ConfigLoader.getConfigLoader().getVaule("salary_import_error_web_folder").trim() + "/" + strTempFile;
    }

    /**
     * @Title: SaveFileFromInputStream
     * @Description: 将传入流保存文件
     * @param stream
     * @param path
     * @param filename
     * @throws IOException
     * @return void 返回类型
     */
    @SuppressWarnings("unused")
    public static void saveFileFromInputStream(InputStream stream, String path, String filename) throws IOException
    {
        try{
            FileOutputStream fs = new FileOutputStream(path + "/" + filename);
            byte[] buffer = new byte[1024 * 1024];
            int bytesum = 0;
            int byteread = 0;
            while ((byteread = stream.read(buffer)) != -1)
            {
                bytesum += byteread;
                fs.write(buffer, 0, byteread);
                fs.flush();
            }
            fs.close();
            stream.close();
        }catch(Exception e){
            logger.error("保存文件出错！",e.getCause());
            e.printStackTrace();
        }
    }

    /**
     * 读取文本文件内容
     * 
     * @param filePathAndName 带有完整绝对路径的文件名
     * @param encoding 文本文件打开的编码方式
     * @return 返回文本文件的内容
     */
    @SuppressWarnings("resource")
    public static String readTxt(String filePathAndName, String encoding) throws IOException
    {
        encoding = encoding.trim();
        StringBuffer str = new StringBuffer("");
        String st = "";
        try
        {
            FileInputStream fs = new FileInputStream(filePathAndName);
            InputStreamReader isr;
            if (encoding.equals(""))
            {
                isr = new InputStreamReader(fs);
            }
            else
            {
                isr = new InputStreamReader(fs, encoding);
            }
            BufferedReader br = new BufferedReader(isr);
            try
            {
                String data = "";
                while ((data = br.readLine()) != null)
                {
                    str.append(data + " ");
                }
            }
            catch (Exception e)
            {
                str.append(e.toString());
            }
            st = str.toString();
        }
        catch (IOException es)
        {
            st = "";
        }
        return st;
    }

    /**
     * 新建目录
     * 
     * @param folderPath 目录
     * @return 返回目录创建后的路径
     */
    public static String createFolder(String folderPath)
    {
        String txt = folderPath;
        try
        {
            java.io.File myFilePath = new java.io.File(txt);
            txt = folderPath;
            if (!myFilePath.exists())
            {
                myFilePath.mkdir();
            }
        }
        catch (Exception e)
        {
            logger.error("创建目录出错！",e.getCause());
            e.printStackTrace();
        }
        return txt;
    }

    /**
     * 多级目录创建
     * 
     * @param folderPath 准备要在本级目录下创建新目录的目录路径 例如 c:myf
     * @param paths 无限级目录参数，各级目录以单数线区分 例如 a|b|c
     * @return 返回创建文件后的路径 例如 c:myfac
     */
    @SuppressWarnings("unused")
    public static String createFolders(String folderPath, String paths)
    {
        String txts = folderPath;
        try
        {
            String txt;
            txts = folderPath;
            StringTokenizer st = new StringTokenizer(paths, "|");
            for (int i = 0; st.hasMoreTokens(); i++)
            {
                txt = st.nextToken().trim();
                if (txts.lastIndexOf("/") != -1)
                {
                    txts = createFolder(txts + txt);
                }
                else
                {
                    txts = createFolder(txts + txt + "/");
                }
            }
        }
        catch (Exception e)
        {
            logger.error("创建目录出错！",e.getCause());
            e.printStackTrace();
        }
        return txts;
    }

    /**
     * 新建文件
     * 
     * @param filePathAndName 文本文件完整绝对路径及文件名
     * @param fileContent 文本文件内容
     * @return
     */
    public static void createFile(String filePathAndName, String fileContent)
    {

        try
        {
            String filePath = filePathAndName;
            filePath = filePath.toString();
            File myFilePath = new File(filePath);
            if (!myFilePath.exists())
            {
                myFilePath.createNewFile();
            }
            FileWriter resultFile = new FileWriter(myFilePath);
            PrintWriter myFile = new PrintWriter(resultFile);
            String strContent = fileContent;
            myFile.println(strContent);
            myFile.close();
            resultFile.close();
        }
        catch (Exception e)
        {
            logger.error("创建文件出错！",e.getCause());
            e.printStackTrace();
        }
    }

    /**
     * 有编码方式的文件创建
     * 
     * @param filePathAndName 文本文件完整绝对路径及文件名
     * @param fileContent 文本文件内容
     * @param encoding 编码方式 例如 GBK 或者 UTF-8
     * @return
     */
    public static void createFile(String filePathAndName, String fileContent, String encoding)
    {

        try
        {
            String filePath = filePathAndName;
            filePath = filePath.toString();
            File myFilePath = new File(filePath);
            if (!myFilePath.exists())
            {
                myFilePath.createNewFile();
            }
            PrintWriter myFile = new PrintWriter(myFilePath, encoding);
            String strContent = fileContent;
            myFile.println(strContent);
            myFile.close();
        }
        catch (Exception e)
        {
            logger.error("创建文件出错！",e.getCause());
            e.printStackTrace();
        }
    }

    /**
     * 删除文件
     * 
     * @param filePathAndName 文本文件完整绝对路径及文件名
     * @return Boolean 成功删除返回true遭遇异常返回false
     */
    public static boolean delFile(String filePathAndName)
    {
        boolean bea = false;
        try
        {
            String filePath = filePathAndName;
            File myDelFile = new File(filePath);
            if (myDelFile.exists())
            {
                myDelFile.delete();
                bea = true;
            }
            else
            {
                bea = false;
            }
        }
        catch (Exception e)
        {
            logger.error("删除文件出错！",e.getCause());
            e.printStackTrace();
        }
        return bea;
    }

    /**
     * 删除文件夹
     * 
     * @param folderPath 文件夹完整绝对路径
     * @return
     */
    public static void delFolder(String folderPath)
    {
        try
        {
            delAllFile(folderPath); // 删除完里面所有内容
            String filePath = folderPath;
            filePath = filePath.toString();
            java.io.File myFilePath = new java.io.File(filePath);
            myFilePath.delete(); // 删除空文件夹
        }
        catch (Exception e)
        {
            logger.error("删除目录出错！",e.getCause());
            e.printStackTrace();
        }
    }

    /**
     * 删除指定文件夹下所有文件
     * 
     * @param path 文件夹完整绝对路径
     * @return
     * @return
     */
    public static boolean delAllFile(String path)
    {
        boolean bea = false;
        
       try{
            File file = new File(path);
            if (!file.exists())
            {
                return bea;
            }
            if (!file.isDirectory())
            {
                return bea;
            }
            String[] tempList = file.list();
            File temp = null;
            for (int i = 0; i < tempList.length; i++)
            {
                if (path.endsWith(File.separator))
                {
                    temp = new File(path + tempList[i]);
                }
                else
                {
                    temp = new File(path + File.separator + tempList[i]);
                }
                if (temp.isFile())
                {
                    temp.delete();
                }
                if (temp.isDirectory())
                {
                    delAllFile(path + "/" + tempList[i]);// 先删除文件夹里面的文件
                    delFolder(path + "/" + tempList[i]);// 再删除空文件夹
                    bea = true;
                }
            }
        }catch(Exception e){
            logger.error("删除指定文件夹下所有文件fail！",e.getCause());
            e.printStackTrace();
        }
        
        return bea;
    }

    /**
     * 复制单个文件
     * 
     * @param oldPathFile 准备复制的文件源
     * @param newPathFile 拷贝到新绝对路径带文件名
     * @return
     */
    @SuppressWarnings("resource")
    public static void copyFile(String oldPathFile, String newPathFile)
    {
        try
        {
            int bytesum = 0;
            int byteread = 0;
            File oldfile = new File(oldPathFile);
            if (oldfile.exists())
            { // 文件存在时
                InputStream inStream = new FileInputStream(oldPathFile); // 读入原文件
                FileOutputStream fs = new FileOutputStream(newPathFile);
                byte[] buffer = new byte[1444];
                while ((byteread = inStream.read(buffer)) != -1)
                {
                    bytesum += byteread; // 字节数 文件大小
                    System.out.println(bytesum);
                    fs.write(buffer, 0, byteread);
                }
                inStream.close();
            }
        }
        catch (Exception e)
        {
            logger.error("复制单个文件失败！",e.getCause());
            e.printStackTrace();
        }
    }

    /**
     * 复制整个文件夹的内容
     * 
     * @param oldPath 准备拷贝的目录
     * @param newPath 指定绝对路径的新目录
     * @return
     */
    public static void copyFolder(String oldPath, String newPath)
    {
        try
        {
            new File(newPath).mkdirs(); // 如果文件夹不存在 则建立新文件夹
            File a = new File(oldPath);
            String[] file = a.list();
            File temp = null;
            for (int i = 0; i < file.length; i++)
            {
                if (oldPath.endsWith(File.separator))
                {
                    temp = new File(oldPath + file[i]);
                }
                else
                {
                    temp = new File(oldPath + File.separator + file[i]);
                }
                if (temp.isFile())
                {
                    FileInputStream input = new FileInputStream(temp);
                    FileOutputStream output = new FileOutputStream(newPath + "/" + (temp.getName()).toString());
                    byte[] b = new byte[1024 * 5];
                    int len;
                    while ((len = input.read(b)) != -1)
                    {
                        output.write(b, 0, len);
                    }
                    output.flush();
                    output.close();
                    input.close();
                }
                if (temp.isDirectory())
                {// 如果是子文件夹
                    copyFolder(oldPath + "/" + file[i], newPath + "/" + file[i]);
                }
            }
        }
        catch (Exception e)
        {
            logger.error("复制整个文件夹的内容失败！",e.getCause());
            e.printStackTrace();
        }
    }

    /**
     * 移动文件
     * 
     * @param oldPath
     * @param newPath
     * @return
     */
    public static void moveFile(String oldPath, String newPath)
    {
        copyFile(oldPath, newPath);
        delFile(oldPath);
    }

    /**
     * 移动目录
     * 
     * @param oldPath
     * @param newPath
     * @return
     */
    public static void moveFolder(String oldPath, String newPath)
    {
        copyFolder(oldPath, newPath);
        delFolder(oldPath);
    }
}
